const express = require('express');
const router = express.Router();
const { Op } = require('sequelize');
const crypto = require('crypto');
const { userModel, getCreateDefaults, getUpdateDefaults } = require('../../models/user.js');
const { createSuccessResponse, createErrorResponse, ErrorTypes } = require('../../middleware/responseHandler.js');

// ========================================
// 📋 CMS用户管理模块功能清单
// ========================================
//
// 🔧 工具函数：
//   • encryptPassword()     : 密码加密函数 (SHA256 + 盐值)
//   • generateSalt()        : 生成随机盐值函数 (16字节)
//
// 🌐 接口路由 (按字母顺序排列)：
//   • /changePassword      : 用户自主修改密码
//   • /getUserById         : 获取用户详情
//   • /getUserList         : 获取用户列表 (分页/搜索/排序)
//   • /login               : 用户登录验证
//   • /logout              : 用户退出登录
//   • /resetPassword       : 管理员重置用户密码
//   • /test                : 路由测试接口
//   • /updateUser          : 修改用户基本信息
//
// ========================================

// 密码加密工具函数
function encryptPassword(password, salt) {
    return crypto.createHash('sha256').update(password + salt).digest('hex');
}

// 生成随机盐
function generateSalt() {
    return crypto.randomBytes(16).toString('hex');
}

// 1. 用户自主修改密码
router.post('/changePassword', (req, res) => {
    return new Promise(async (resolve, reject) => {
        try {
            // 检查请求体是否为空或格式错误
            if (!req.body || typeof req.body !== 'object') {
                const error = new Error('请求体格式错误，请确保Content-Type为application/json');
                res.json(createErrorResponse(error, ErrorTypes.VALIDATION));
                return;
            }

            const { user_id, old_password, new_password } = req.body;

            if (!user_id || !old_password || !new_password) {
                const error = new Error('用户ID、旧密码和新密码为必填字段');
                res.json(createErrorResponse(error, ErrorTypes.VALIDATION));
                return;
            }

            // 查找用户并验证旧密码
            const userData = await userModel.findOne({
                where: {
                    user_id: parseInt(user_id),
                    is_delete: 0
                }
            });

            if (!userData) {
                const error = new Error('用户不存在');
                res.json(createErrorResponse(error, ErrorTypes.NOT_FOUND));
                return;
            }

            // 验证旧密码
            const encryptedOldPassword = encryptPassword(old_password, userData.password_solt);
            if (encryptedOldPassword !== userData.password_text) {
                const error = new Error('旧密码错误');
                res.json(createErrorResponse(error, ErrorTypes.AUTHENTICATION));
                return;
            }

            // 生成新的加密盐和加密密码
            const _newSalt = generateSalt();
            const _encryptedNewPassword = encryptPassword(new_password, _newSalt);

            // 更新用户密码和加密盐
            await userModel.update(
                {
                    password_text: _encryptedNewPassword,
                    password_solt: _newSalt,
                    ...getUpdateDefaults()
                },
                { where: { user_id: parseInt(user_id) } }
            );

            res.json(createSuccessResponse({
                user_id: parseInt(user_id),
                new_password: new_password
            }, "密码修改成功"));
        } catch (error) {
            console.error('修改密码错误:', error);
            res.json(createErrorResponse(error, ErrorTypes.INTERNAL));
        }
    });
});

// 2. 获取用户详情
router.post('/getUserById', (req, res) => {
    return new Promise(async (resolve, reject) => {
        try {
            // 检查请求体是否为空或格式错误
            if (!req.body || typeof req.body !== 'object') {
                const error = new Error('请求体格式错误，请确保Content-Type为application/json');
                res.json(createErrorResponse(error, ErrorTypes.VALIDATION));
                return;
            }

            const { user_id } = req.body;

            if (!user_id || isNaN(parseInt(user_id))) {
                const error = new Error('用户ID无效');
                res.json(createErrorResponse(error, ErrorTypes.VALIDATION));
                return;
            }

            const _userData = await userModel.findOne({
                where: {
                    user_id: parseInt(user_id),
                    is_delete: 0
                },
                attributes: { exclude: ['password_text', 'password_solt'] }
            });

            if (!_userData) {
                const error = new Error('用户不存在');
                res.json(createErrorResponse(error, ErrorTypes.NOT_FOUND));
                return;
            }

            res.json(createSuccessResponse(_userData, "获取用户详情成功"));
        } catch (error) {
            console.error('获取用户详情错误:', error);
            // 如果是JSON解析错误，返回更明确的错误信息
            if (error.message.includes('JSON') || error.message.includes('Unexpected token')) {
                const jsonError = new Error('请求体JSON格式错误，请检查请求数据格式');
                res.json(createErrorResponse(jsonError, ErrorTypes.VALIDATION));
            } else {
                res.json(createErrorResponse(error, ErrorTypes.INTERNAL));
            }
        }
    });
});

// 3. 获取用户列表
// 功能：支持分页、关键字搜索、多字段排序和正式用户筛选的用户列表查询接口
// 请求参数：
// - page: 页码，默认1
// - size: 每页数量，默认10，0表示获取所有数据
// - keyword: 关键字搜索（中文名、真实姓名、手机号、身份证）
// - sortBy: 排序字段数组，格式[{"字段名": "排序方向"}]
// - is_formal: 正式用户筛选（0/1，空值不筛选）
// 基本逻辑：
// 1. 解析并验证请求参数
// 2. 构建查询条件（软删除过滤、正式用户筛选、关键字搜索）
// 3. 处理多字段排序，验证字段和排序方向的有效性
// 4. 执行分页查询（总数统计 + 数据查询）
// 5. 返回用户列表和分页信息
router.post('/getUserList', (req, res) => {
    return new Promise(async (resolve, reject) => {
        try {
            const {
                page = 1,
                size = 10,
                keyword = '',
                sortBy = [{ "user_id": "DESC" }],
                is_formal = ''
            } = req.body;

            let _offset = (parseInt(page) - 1) * parseInt(size);
            let _whereClause = {
                is_delete: 0
            };

            // 正式用户筛选条件
            if (is_formal !== '' && is_formal !== undefined) {
                _whereClause.is_formal = parseInt(is_formal);
            }

            // 关键字搜索条件
            if (keyword) {
                _whereClause[Op.or] = [
                    { name_cn: { [Op.like]: `%${keyword}%` } },
                    { real_name: { [Op.like]: `%${keyword}%` } },
                    { moblie: { [Op.like]: `%${keyword}%` } },
                    { card_number: { [Op.like]: `%${keyword}%` } }
                ];
            }

            // 处理排序字段
            let _orderClause = [];
            if (Array.isArray(sortBy) && sortBy.length > 0) {
                // 验证排序字段
                const _allowedSortFields = ['user_id', 'name_en', 'name_cn', 'real_name', 'create_time', 'update_time', 'user_level'];
                const _allowedOrderDirections = ['ASC', 'DESC'];

                sortBy.forEach(sortItem => {
                    const field = Object.keys(sortItem)[0];
                    const direction = sortItem[field];

                    if (_allowedSortFields.includes(field) && _allowedOrderDirections.includes(direction.toUpperCase())) {
                        _orderClause.push([field, direction.toUpperCase()]);
                    }
                });
            }

            // 如果没有有效的排序条件，使用默认排序
            if (_orderClause.length === 0) {
                _orderClause = [['user_id', 'DESC']];
            }

            // 查询总数
            let _countResult = await userModel.count({
                where: _whereClause
            });

            // 查询数据
            let _queryOptions = {
                where: _whereClause,
                order: _orderClause,
                attributes: { exclude: ['password_text', 'password_solt'] }
            };

            // 如果size为0，表示请求所有数据，不设置limit和offset
            if (parseInt(size) > 0) {
                _queryOptions.limit = parseInt(size);
                _queryOptions.offset = _offset;
            }

            let _dataResult = await userModel.findAll(_queryOptions);

            let _total = _countResult;
            let _totalPages = parseInt(size) > 0 ? Math.ceil(_total / parseInt(size)) : 1;

            res.json(createSuccessResponse({
                users: _dataResult,
                pagination: {
                    page: parseInt(page),
                    size: parseInt(size),
                    total: _total,
                    totalPages: _totalPages,
                    hasNext: parseInt(page) < _totalPages,
                    hasPrev: parseInt(page) > 1
                }
            }, "获取用户列表成功"));
        } catch (error) {
            console.error('获取用户列表错误:', error);
            res.json(createErrorResponse(error, ErrorTypes.INTERNAL));
        }
    });
});

// 4. 用户登录
router.post('/login', (req, res) => {
    return new Promise(async (resolve, reject) => {
        try {
            // 检查请求体是否为空或格式错误
            if (!req.body || typeof req.body !== 'object') {
                const error = new Error('请求体格式错误，请确保Content-Type为application/json');
                res.json(createErrorResponse(error, ErrorTypes.VALIDATION));
                return;
            }

            const { name_en, password_text } = req.body;

            if (!name_en || !password_text) {
                const error = new Error('账号和密码为必填字段');
                res.json(createErrorResponse(error, ErrorTypes.VALIDATION));
                return;
            }

            // 先查找用户，获取加密盐
            const userData = await userModel.findOne({
                where: {
                    name_en: name_en,
                    is_delete: 0
                }
            });

            if (!userData) {
                const error = new Error('账号或密码错误');
                res.json(createErrorResponse(error, ErrorTypes.AUTHENTICATION));
                return;
            }

            // 使用加密盐验证密码
            const encryptedInputPassword = encryptPassword(password_text, userData.password_solt);

            if (encryptedInputPassword !== userData.password_text) {
                const error = new Error('账号或密码错误');
                res.json(createErrorResponse(error, ErrorTypes.AUTHENTICATION));
                return;
            }

            // 返回用户信息（不包含密码）
            const userInfo = userData.toJSON();
            delete userInfo.password_text;
            delete userInfo.password_solt;

            res.json(createSuccessResponse(userInfo, "登录成功"));
        } catch (error) {
            console.error('用户登录错误:', error);
            res.json(createErrorResponse(error, ErrorTypes.INTERNAL));
        }
    });
});

// 5. 用户退出登录
router.post('/logout', (req, res) => {
    return new Promise(async (resolve, reject) => {
        try {
            // 检查请求体是否为空或格式错误
            if (!req.body || typeof req.body !== 'object') {
                const error = new Error('请求体格式错误，请确保Content-Type为application/json');
                res.json(createErrorResponse(error, ErrorTypes.VALIDATION));
                return;
            }

            const { user_id } = req.body;

            if (!user_id) {
                const error = new Error('用户ID为必填字段');
                res.json(createErrorResponse(error, ErrorTypes.VALIDATION));
                return;
            }

            // 验证用户是否存在
            const userData = await userModel.findOne({
                where: {
                    user_id: parseInt(user_id),
                    is_delete: 0
                }
            });

            if (!userData) {
                const error = new Error('用户不存在');
                res.json(createErrorResponse(error, ErrorTypes.NOT_FOUND));
                return;
            }

            // TODO: 后期使用token时的逻辑
            // 1. 验证token的有效性
            // 2. 将token加入黑名单或设置过期时间
            // 3. 清除服务器端的session信息
            // 4. 记录退出登录日志

            res.json(createSuccessResponse(null, "退出登录成功"));
        } catch (error) {
            console.error('退出登录错误:', error);
            res.json(createErrorResponse(error, ErrorTypes.INTERNAL));
        }
    });
});

// 6. 管理员重置用户密码
router.post('/resetPassword', (req, res) => {
    return new Promise(async (resolve, reject) => {
        try {
            // 检查请求体是否为空或格式错误
            if (!req.body || typeof req.body !== 'object') {
                const error = new Error('请求体格式错误，请确保Content-Type为application/json');
                res.json(createErrorResponse(error, ErrorTypes.VALIDATION));
                return;
            }

            const { user_id } = req.body;
            console.log('重置密码请求体:', req.body);
            console.log('请求头Content-Type:', req.headers['content-type']);
            console.log('解构后的user_id:', user_id);
            console.log('user_id类型:', typeof user_id);
            console.log('user_id是否为空:', !user_id);
            if (!user_id) {
                const error = new Error("缺少必要的参数user_id");
                res.json(createErrorResponse(error, ErrorTypes.VALIDATION));
                return;
            }

            // TODO: 权限验证相关逻辑，以后实现
            // 1. 验证当前登录用户是否为管理员
            // 2. 验证管理员是否有重置密码的权限
            // 3. 验证管理员是否有操作该用户的权限

            // 检查需要重置的用户是否存在
            const userData = await userModel.findOne({
                where: {
                    user_id: parseInt(user_id),
                    is_delete: 0
                }
            });

            if (!userData) {
                const error = new Error('用户不存在');
                res.json(createErrorResponse(error, ErrorTypes.NOT_FOUND));
                return;
            }

            // 生成新的随机加密盐
            const _newSalt = generateSalt();

            // 固定密码字符串
            const _fixedPassword = 'a123456789';

            // 使用加密盐和固定密码生成加密后的密码
            const _encryptedPassword = encryptPassword(_fixedPassword, _newSalt);

            // 更新用户密码和加密盐
            await userModel.update(
                {
                    password_text: _encryptedPassword,
                    password_solt: _newSalt,
                    ...getUpdateDefaults()
                },
                { where: { user_id: parseInt(user_id) } }
            );

            res.json(createSuccessResponse({
                user_id: parseInt(user_id),
                reset_password: _fixedPassword
            }, "密码重置成功"));
        } catch (error) {
            console.error('重置密码错误:', error);
            res.json(createErrorResponse(error, ErrorTypes.INTERNAL));
        }
    });
});

// 7. 路由测试接口
router.post('/test', (req, res) => {
    return new Promise(async (resolve, reject) => {
        try {
            res.json(createSuccessResponse({
                message: 'CMS用户路由测试成功',
                timestamp: new Date().toISOString(),
                data: {
                    id: 1,
                    name: '测试数据',
                    status: 'OK'
                }
            }, "测试接口调用成功"));
        } catch (error) {
            console.error('测试接口错误:', error);
            res.json(createErrorResponse(error, ErrorTypes.INTERNAL));
        }
    });
});

// 8. 修改用户基本信息
router.post('/updateUser', (req, res) => {
    return new Promise(async (resolve, reject) => {
        try {
            // 检查请求体是否为空或格式错误
            if (!req.body || typeof req.body !== 'object') {
                const error = new Error('请求体格式错误，请确保Content-Type为application/json');
                res.json(createErrorResponse(error, ErrorTypes.VALIDATION));
                return;
            }

            const { user_id, ...updateData } = req.body;

            if (!user_id) {
                const error = new Error('用户ID为必填字段');
                res.json(createErrorResponse(error, ErrorTypes.VALIDATION));
                return;
            }

            const existingUser = await userModel.findOne({
                where: {
                    user_id: parseInt(user_id),
                    is_delete: 0
                }
            });

            if (!existingUser) {
                const error = new Error('用户不存在');
                res.json(createErrorResponse(error, ErrorTypes.NOT_FOUND));
                return;
            }

            // TODO: 权限验证相关逻辑，以后实现
            // 1. 验证当前登录用户身份（从token或session获取）
            // 2. 判断操作类型：
            //    - 自己修改自己信息：验证user_id是否与当前登录用户一致
            //    - 修改他人信息：验证当前用户是否有管理员权限
            // 3. 根据操作类型执行不同的验证逻辑
            // 4. 记录操作日志（可选）

            // 如果更新账号，检查是否重复
            if (updateData.name_en && updateData.name_en !== existingUser.name_en) {
                const nameCheck = await userModel.findOne({
                    where: { name_en: updateData.name_en }
                });

                if (nameCheck) {
                    const error = new Error('账号已存在');
                    res.json(createErrorResponse(error, ErrorTypes.CONFLICT));
                    return;
                }
            }

            // 构建更新数据
            let _dataToUpdate = getUpdateDefaults();

            // 只更新提供的字段
            const _allowedFields = ['name_en', 'name_cn', 'real_name', 'moblie', 'card_number', 'email', 'address', 'avatar', 'user_level', 'icon_id', 'openid', 'is_formal'];
            _allowedFields.forEach(field => {
                if (updateData[field] !== undefined) {
                    _dataToUpdate[field] = updateData[field];
                }
            });

            await userModel.update(_dataToUpdate, {
                where: { user_id: parseInt(user_id) }
            });

            const _updatedUser = await userModel.findOne({
                where: { user_id: parseInt(user_id) },
                attributes: { exclude: ['password_text', 'password_solt'] }
            });

            res.json(createSuccessResponse(_updatedUser, "更新用户信息成功"));
        } catch (error) {
            console.error('更新用户信息错误:', error);
            res.json(createErrorResponse(error, ErrorTypes.INTERNAL));
        }
    });
});

module.exports = router;